home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / modules / ModuleManager.as < prev    next >
Text File  |  2014-03-27  |  15KB  |  566 lines
  1. package mx.modules
  2. {
  3.    import mx.core.IFlexModuleFactory;
  4.    import mx.core.mx_internal;
  5.    
  6.    use namespace mx_internal;
  7.    
  8.    public class ModuleManager
  9.    {
  10.       
  11.       mx_internal static const VERSION:String = "3.0.0.0";
  12.        
  13.       
  14.       public function ModuleManager()
  15.       {
  16.          super();
  17.       }
  18.       
  19.       public static function getModule(param1:String) : IModuleInfo
  20.       {
  21.          return getSingleton().getModule(param1);
  22.       }
  23.       
  24.       private static function getSingleton() : Object
  25.       {
  26.          if(!ModuleManagerGlobals.managerSingleton)
  27.          {
  28.             ModuleManagerGlobals.managerSingleton = new ModuleManagerImpl();
  29.          }
  30.          return ModuleManagerGlobals.managerSingleton;
  31.       }
  32.       
  33.       public static function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  34.       {
  35.          return getSingleton().getAssociatedFactory(param1);
  36.       }
  37.    }
  38. }
  39.  
  40. import flash.events.EventDispatcher;
  41. import flash.system.ApplicationDomain;
  42. import flash.system.SecurityDomain;
  43. import mx.core.IFlexModuleFactory;
  44. import mx.events.ModuleEvent;
  45. import mx.modules.IModuleInfo;
  46.  
  47. class ModuleInfoProxy extends EventDispatcher implements IModuleInfo
  48. {
  49.     
  50.    
  51.    private var _data:Object;
  52.    
  53.    private var info:ModuleInfo;
  54.    
  55.    private var referenced:Boolean = false;
  56.    
  57.    function ModuleInfoProxy(param1:ModuleInfo)
  58.    {
  59.       super();
  60.       this.info = param1;
  61.       param1.addEventListener(ModuleEvent.SETUP,moduleEventHandler,false,0,true);
  62.       param1.addEventListener(ModuleEvent.PROGRESS,moduleEventHandler,false,0,true);
  63.       param1.addEventListener(ModuleEvent.READY,moduleEventHandler,false,0,true);
  64.       param1.addEventListener(ModuleEvent.ERROR,moduleEventHandler,false,0,true);
  65.       param1.addEventListener(ModuleEvent.UNLOAD,moduleEventHandler,false,0,true);
  66.    }
  67.    
  68.    public function get loaded() : Boolean
  69.    {
  70.       return info.loaded;
  71.    }
  72.    
  73.    public function release() : void
  74.    {
  75.       if(referenced)
  76.       {
  77.          info.removeReference();
  78.          referenced = false;
  79.       }
  80.    }
  81.    
  82.    public function get error() : Boolean
  83.    {
  84.       return info.error;
  85.    }
  86.    
  87.    public function get factory() : IFlexModuleFactory
  88.    {
  89.       return info.factory;
  90.    }
  91.    
  92.    public function publish(param1:IFlexModuleFactory) : void
  93.    {
  94.       info.publish(param1);
  95.    }
  96.    
  97.    public function set data(param1:Object) : void
  98.    {
  99.       _data = param1;
  100.    }
  101.    
  102.    public function get ready() : Boolean
  103.    {
  104.       return info.ready;
  105.    }
  106.    
  107.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null) : void
  108.    {
  109.       var _loc3_:ModuleEvent = null;
  110.       info.resurrect();
  111.       if(!referenced)
  112.       {
  113.          info.addReference();
  114.          referenced = true;
  115.       }
  116.       if(info.error)
  117.       {
  118.          dispatchEvent(new ModuleEvent(ModuleEvent.ERROR));
  119.       }
  120.       else if(info.loaded)
  121.       {
  122.          if(info.setup)
  123.          {
  124.             dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  125.             if(info.ready)
  126.             {
  127.                _loc3_ = new ModuleEvent(ModuleEvent.PROGRESS);
  128.                _loc3_.bytesLoaded = info.size;
  129.                _loc3_.bytesTotal = info.size;
  130.                dispatchEvent(_loc3_);
  131.                dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  132.             }
  133.          }
  134.       }
  135.       else
  136.       {
  137.          info.load(param1,param2);
  138.       }
  139.    }
  140.    
  141.    private function moduleEventHandler(param1:ModuleEvent) : void
  142.    {
  143.       dispatchEvent(param1);
  144.    }
  145.    
  146.    public function get url() : String
  147.    {
  148.       return info.url;
  149.    }
  150.    
  151.    public function get data() : Object
  152.    {
  153.       return _data;
  154.    }
  155.    
  156.    public function get setup() : Boolean
  157.    {
  158.       return info.setup;
  159.    }
  160.    
  161.    public function unload() : void
  162.    {
  163.       info.unload();
  164.       info.removeEventListener(ModuleEvent.SETUP,moduleEventHandler);
  165.       info.removeEventListener(ModuleEvent.PROGRESS,moduleEventHandler);
  166.       info.removeEventListener(ModuleEvent.READY,moduleEventHandler);
  167.       info.removeEventListener(ModuleEvent.ERROR,moduleEventHandler);
  168.       info.removeEventListener(ModuleEvent.UNLOAD,moduleEventHandler);
  169.    }
  170. }
  171.  
  172. import flash.events.EventDispatcher;
  173. import flash.system.ApplicationDomain;
  174. import flash.utils.getQualifiedClassName;
  175. import mx.core.IFlexModuleFactory;
  176. import mx.modules.IModuleInfo;
  177.  
  178. class ModuleManagerImpl extends EventDispatcher
  179. {
  180.     
  181.    
  182.    private var moduleList:Object;
  183.    
  184.    function ModuleManagerImpl()
  185.    {
  186.       moduleList = {};
  187.       super();
  188.    }
  189.    
  190.    public function getModule(param1:String) : IModuleInfo
  191.    {
  192.       var _loc2_:ModuleInfo = moduleList[param1] as ModuleInfo;
  193.       if(!_loc2_)
  194.       {
  195.          _loc2_ = new ModuleInfo(param1);
  196.          moduleList[param1] = _loc2_;
  197.       }
  198.       return new ModuleInfoProxy(_loc2_);
  199.    }
  200.    
  201.    public function getAssociatedFactory(param1:Object) : IFlexModuleFactory
  202.    {
  203.       var m:Object = null;
  204.       var info:ModuleInfo = null;
  205.       var domain:ApplicationDomain = null;
  206.       var cls:Class = null;
  207.       var object:Object = param1;
  208.       var className:String = getQualifiedClassName(object);
  209.       for each(m in moduleList)
  210.       {
  211.          info = m as ModuleInfo;
  212.          if(info.ready)
  213.          {
  214.             domain = info.applicationDomain;
  215.             try
  216.             {
  217.                cls = Class(domain.getDefinition(className));
  218.                if(object is cls)
  219.                {
  220.                   return info.factory;
  221.                }
  222.             }
  223.             catch(error:Error)
  224.             {
  225.                continue;
  226.             }
  227.          }
  228.       }
  229.       return null;
  230.    }
  231. }
  232.  
  233. import flash.display.Loader;
  234. import flash.events.ErrorEvent;
  235. import flash.events.Event;
  236. import flash.events.EventDispatcher;
  237. import flash.events.IOErrorEvent;
  238. import flash.events.ProgressEvent;
  239. import flash.events.SecurityErrorEvent;
  240. import flash.net.URLRequest;
  241. import flash.system.ApplicationDomain;
  242. import flash.system.LoaderContext;
  243. import flash.system.Security;
  244. import flash.system.SecurityDomain;
  245. import flash.utils.Dictionary;
  246. import mx.core.IFlexModuleFactory;
  247. import mx.events.ModuleEvent;
  248.  
  249. class ModuleInfo extends EventDispatcher
  250. {
  251.     
  252.    
  253.    private var _error:Boolean = false;
  254.    
  255.    private var loader:Loader;
  256.    
  257.    private var factoryInfo:FactoryInfo;
  258.    
  259.    private var limbo:Dictionary;
  260.    
  261.    private var _loaded:Boolean = false;
  262.    
  263.    private var _ready:Boolean = false;
  264.    
  265.    private var numReferences:int = 0;
  266.    
  267.    private var _url:String;
  268.    
  269.    private var _setup:Boolean = false;
  270.    
  271.    function ModuleInfo(param1:String)
  272.    {
  273.       super();
  274.       _url = param1;
  275.    }
  276.    
  277.    private function clearLoader() : void
  278.    {
  279.       if(loader)
  280.       {
  281.          if(loader.contentLoaderInfo)
  282.          {
  283.             loader.contentLoaderInfo.removeEventListener(Event.INIT,initHandler);
  284.             loader.contentLoaderInfo.removeEventListener(Event.COMPLETE,completeHandler);
  285.             loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS,progressHandler);
  286.             loader.contentLoaderInfo.removeEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  287.             loader.contentLoaderInfo.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  288.          }
  289.          try
  290.          {
  291.             if(loader.content)
  292.             {
  293.                loader.content.removeEventListener("ready",readyHandler);
  294.             }
  295.          }
  296.          catch(error:Error)
  297.          {
  298.          }
  299.          if(_loaded)
  300.          {
  301.             try
  302.             {
  303.                loader.close();
  304.             }
  305.             catch(error:Error)
  306.             {
  307.             }
  308.          }
  309.          try
  310.          {
  311.             loader.unload();
  312.          }
  313.          catch(error:Error)
  314.          {
  315.          }
  316.          loader = null;
  317.       }
  318.    }
  319.    
  320.    public function get size() : int
  321.    {
  322.       return !limbo && factoryInfo ? int(factoryInfo.bytesTotal) : 0;
  323.    }
  324.    
  325.    public function get loaded() : Boolean
  326.    {
  327.       return !limbo ? Boolean(_loaded) : false;
  328.    }
  329.    
  330.    public function release() : void
  331.    {
  332.       if(_ready && !limbo)
  333.       {
  334.          limbo = new Dictionary(true);
  335.          limbo[factoryInfo] = 1;
  336.          factoryInfo = null;
  337.       }
  338.       else
  339.       {
  340.          unload();
  341.       }
  342.    }
  343.    
  344.    public function get error() : Boolean
  345.    {
  346.       return !limbo ? Boolean(_error) : false;
  347.    }
  348.    
  349.    public function get factory() : IFlexModuleFactory
  350.    {
  351.       return !limbo && factoryInfo ? factoryInfo.factory : null;
  352.    }
  353.    
  354.    public function completeHandler(param1:Event) : void
  355.    {
  356.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  357.       _loc2_.bytesLoaded = loader.contentLoaderInfo.bytesLoaded;
  358.       _loc2_.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  359.       dispatchEvent(_loc2_);
  360.    }
  361.    
  362.    public function publish(param1:IFlexModuleFactory) : void
  363.    {
  364.       if(factoryInfo)
  365.       {
  366.          return;
  367.       }
  368.       if(_url.indexOf("published://") != 0)
  369.       {
  370.          return;
  371.       }
  372.       factoryInfo = new FactoryInfo();
  373.       factoryInfo.factory = param1;
  374.       _loaded = true;
  375.       _setup = true;
  376.       _ready = true;
  377.       _error = false;
  378.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  379.       dispatchEvent(new ModuleEvent(ModuleEvent.PROGRESS));
  380.       dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  381.    }
  382.    
  383.    public function initHandler(param1:Event) : void
  384.    {
  385.       var moduleEvent:ModuleEvent = null;
  386.       var event:Event = param1;
  387.       factoryInfo = new FactoryInfo();
  388.       try
  389.       {
  390.          factoryInfo.factory = loader.content as IFlexModuleFactory;
  391.       }
  392.       catch(error:Error)
  393.       {
  394.       }
  395.       if(!factoryInfo.factory)
  396.       {
  397.          moduleEvent = new ModuleEvent(ModuleEvent.ERROR,event.bubbles,event.cancelable);
  398.          moduleEvent.bytesLoaded = 0;
  399.          moduleEvent.bytesTotal = 0;
  400.          moduleEvent.errorText = "SWF is not a loadable module";
  401.          dispatchEvent(moduleEvent);
  402.          return;
  403.       }
  404.       loader.content.addEventListener("ready",readyHandler);
  405.       try
  406.       {
  407.          factoryInfo.applicationDomain = loader.contentLoaderInfo.applicationDomain;
  408.       }
  409.       catch(error:Error)
  410.       {
  411.       }
  412.       _setup = true;
  413.       dispatchEvent(new ModuleEvent(ModuleEvent.SETUP));
  414.    }
  415.    
  416.    public function resurrect() : void
  417.    {
  418.       var _loc1_:* = null;
  419.       if(!factoryInfo && limbo)
  420.       {
  421.          var _loc2_:int = 0;
  422.          var _loc3_:* = limbo;
  423.          for(_loc1_ in _loc3_)
  424.          {
  425.             factoryInfo = _loc1_ as FactoryInfo;
  426.          }
  427.          limbo = null;
  428.       }
  429.       if(!factoryInfo)
  430.       {
  431.          if(_loaded)
  432.          {
  433.             dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  434.          }
  435.          loader = null;
  436.          _loaded = false;
  437.          _setup = false;
  438.          _ready = false;
  439.          _error = false;
  440.       }
  441.    }
  442.    
  443.    public function errorHandler(param1:ErrorEvent) : void
  444.    {
  445.       _error = true;
  446.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.ERROR,param1.bubbles,param1.cancelable);
  447.       _loc2_.bytesLoaded = 0;
  448.       _loc2_.bytesTotal = 0;
  449.       _loc2_.errorText = param1.text;
  450.       dispatchEvent(_loc2_);
  451.    }
  452.    
  453.    public function get ready() : Boolean
  454.    {
  455.       return !limbo ? Boolean(_ready) : false;
  456.    }
  457.    
  458.    public function removeReference() : void
  459.    {
  460.       --numReferences;
  461.       if(numReferences == 0)
  462.       {
  463.          release();
  464.       }
  465.    }
  466.    
  467.    public function addReference() : void
  468.    {
  469.       ++numReferences;
  470.    }
  471.    
  472.    public function progressHandler(param1:ProgressEvent) : void
  473.    {
  474.       var _loc2_:ModuleEvent = new ModuleEvent(ModuleEvent.PROGRESS,param1.bubbles,param1.cancelable);
  475.       _loc2_.bytesLoaded = param1.bytesLoaded;
  476.       _loc2_.bytesTotal = param1.bytesTotal;
  477.       dispatchEvent(_loc2_);
  478.    }
  479.    
  480.    public function load(param1:ApplicationDomain = null, param2:SecurityDomain = null) : void
  481.    {
  482.       if(_loaded)
  483.       {
  484.          return;
  485.       }
  486.       _loaded = true;
  487.       limbo = null;
  488.       if(_url.indexOf("published://") == 0)
  489.       {
  490.          return;
  491.       }
  492.       var _loc3_:URLRequest = new URLRequest(_url);
  493.       var _loc4_:LoaderContext;
  494.       (_loc4_ = new LoaderContext()).applicationDomain = !!param1 ? param1 : new ApplicationDomain(ApplicationDomain.currentDomain);
  495.       _loc4_.securityDomain = param2;
  496.       if(param2 == null && Security.sandboxType == Security.REMOTE)
  497.       {
  498.          _loc4_.securityDomain = SecurityDomain.currentDomain;
  499.       }
  500.       loader = new Loader();
  501.       loader.contentLoaderInfo.addEventListener(Event.INIT,initHandler);
  502.       loader.contentLoaderInfo.addEventListener(Event.COMPLETE,completeHandler);
  503.       loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,progressHandler);
  504.       loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  505.       loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,errorHandler);
  506.       loader.load(_loc3_,_loc4_);
  507.    }
  508.    
  509.    public function get url() : String
  510.    {
  511.       return _url;
  512.    }
  513.    
  514.    public function get applicationDomain() : ApplicationDomain
  515.    {
  516.       return !limbo && factoryInfo ? factoryInfo.applicationDomain : null;
  517.    }
  518.    
  519.    public function readyHandler(param1:Event) : void
  520.    {
  521.       _ready = true;
  522.       factoryInfo.bytesTotal = loader.contentLoaderInfo.bytesTotal;
  523.       clearLoader();
  524.       dispatchEvent(new ModuleEvent(ModuleEvent.READY));
  525.    }
  526.    
  527.    public function get setup() : Boolean
  528.    {
  529.       return !limbo ? Boolean(_setup) : false;
  530.    }
  531.    
  532.    public function unload() : void
  533.    {
  534.       clearLoader();
  535.       if(_loaded)
  536.       {
  537.          dispatchEvent(new ModuleEvent(ModuleEvent.UNLOAD));
  538.       }
  539.       limbo = null;
  540.       factoryInfo = null;
  541.       _loaded = false;
  542.       _setup = false;
  543.       _ready = false;
  544.       _error = false;
  545.    }
  546. }
  547.  
  548. import flash.system.ApplicationDomain;
  549. import mx.core.IFlexModuleFactory;
  550.  
  551. class FactoryInfo
  552. {
  553.     
  554.    
  555.    public var bytesTotal:int = 0;
  556.    
  557.    public var factory:IFlexModuleFactory;
  558.    
  559.    public var applicationDomain:ApplicationDomain;
  560.    
  561.    function FactoryInfo()
  562.    {
  563.       super();
  564.    }
  565. }
  566.